// pages/group/index.ts
import { formatMessageDate, formatAgreeDate } from "../../../utils/format";
import { formatTimestamp } from "../../../utils/index";
import {
    userCheckChatted,
    userChatted,
    rewriteImMessage,
    userTargetInfo,
    getUserRelation,
} from "../../../utils/api";
import tran from "../../../utils/language";
import dayjs from "dayjs";
Page({
    /**
     * 页面的初始数据
     */
    data: {
        _t: tran._t("group"),
        _tBase: tran._t("base"),
        showEventPopup: false,
        messageData: [] as messageType[],
        targetUserInfo: {
            userId: "",
            avatarurl: "",
        },
        textareaValue: "",
        loginInfo: {
            userId: "",
            avatar: "",
        },
        keyboardHeight: "0",
        messageRefHeight: "calc(100% - 286rpx)",
        pageSize: 30,
        pageNum: 1,
        blackNameFlag: false,
        scrollTop: 0,
        checkChatFlag: false,
        cursor: -1,
        loading: false,
        scrolltoupperFlag: false,
        msgFlag: true,
        currentTimestamp: Math.floor(Date.now()), // 当前时间戳（秒）
        contentHeight: 0, // 内容高度
        tempMessageId: 0, // 临时消息ID
        isInput: false,
        showDownPopup: false,
        homeFriendInfo: {},
        hideSendInp: false,
        friendStatus: {
            friend: true,
            blockedByTarget: false,
            logout: false,
        },
    },
    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options: any) {
        const loginInfo = wx.getStorageSync("userInfo");
        const history = wx.getStorageSync(loginInfo.userId) || [];
        this.setData({
            loginInfo,
            messageData: history || [],
        });
        if (options) {
            const info = JSON.parse(options.info);
            console.log("====================================");
            console.log(info);
            console.log("====================================");
            this.setData(
                {
                    targetUserInfo: info,
                },
                () => {
                    this.getUserRe();
                    this.getHistoryList();
                    this.checkChat();
                }
            );
        }
        this.takeOverMsg();
    },
    onShow() {
        wx.onKeyboardHeightChange((res) => {
            this.setData(
                {
                    messageRefHeight:
                        res.height === 0
                            ? `calc(100% - 286rpx)`
                            : `calc(100% - 286rpx - ${res.height - 40}px)`,
                    keyboardHeight:
                        res.height === 0 ? `0px` : `${res.height - 40}px`,
                },
                () => {
                    this.setScrollToBottom();
                }
            );
        });
    },
    messageChange(msgList: any) {
        this.setData({
            messageData: msgList,
        });
    },
    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {},
    onHide() {
        wx.conn.removeEventHandler("eventName");
    },
    // 获取用户关系
    getUserRe() {
        getUserRelation({ targetUserId: this.data.targetUserInfo.userId }).then(
            (res) => {
                console.log(res);
                if (!res || !res.friend || res.blockedByTarget) {
                    this.setData({
                        hideSendInp: true,
                        friendStatus: {
                            friend: res && !res.friend ? res.friend : true,
                            blockedByTarget:
                                res && res.blockedByTarget
                                    ? res.blockedByTarget
                                    : false,
                            logout: res ? false : true,
                        },
                    });
                } else {
                    this.data.hideSendInp = false;
                }
            }
        );
    },
    /**
     * 获取点击的用户详情
     */
    getOtherUserInfo() {
        const params = {
            targetUserId: this.data.targetUserInfo.userId,
        };
        userTargetInfo(params).then((res: any) => {
            console.log(res);
            if (res.friendSourceInfo && res.friendSourceInfo.agreeTime) {
                res.friendSourceInfo.agreeTimeShow = formatAgreeDate(
                    res.friendSourceInfo.agreeTimeShow
                );
            }
            res.homeFriendInfoFlag = "1"; // 首页过去的类型判断
            this.setData({ showDownPopup: true, homeFriendInfo: res });
        });
    },
    //
    closeDownPopup(type) {
        console.log(type);
        if (type.detail == "del") {
            console.log("====================================");
            console.log("删除");
            console.log("====================================");
            wx.navigateTo({
                url: "/pages/friends/index",
            });
        }
        const downPopup = this.selectComponent("#down-popup");
        this.setData({ showDownPopup: false });
        downPopup && downPopup.hidePopup();
    },
    /**
     * 检测是否与对方聊过天
     */
    checkChat() {
        const { targetUserInfo } = this.data;
        const params = {
            targetUserId: targetUserInfo.userId,
        };
        userCheckChatted(params).then((res: any) => {
            this.setData({
                checkChatFlag: res,
            });
        });
    },
    /**
     * 标记与对方聊天
     */
    chatMark() {
        const { targetUserInfo, checkChatFlag } = this.data;
        const that = this;
        if (!checkChatFlag) {
            // checkChatFlag为false,就说明没有和对方聊过天，就需要调用标记与对方聊天的接口
            const params = {
                targetUserId: targetUserInfo.userId,
            };
            userChatted(params).then((res: any) => {
                // 调用标记聊过天接口成功后，就不再调用此接口
                that.setData({
                    checkChatFlag: true,
                });
            });
        }
    },
    /**
     * 将scroll-view中的内容滚动到最底部
     */
    setScrollToBottom() {
        const query = wx.createSelectorQuery();
        // 获取类名为message-box
        query
            .select(".message-box")
            .boundingClientRect((rect) => {
                this.setData({
                    scrollTop: rect.height
                        ? rect.height * 1 + 100000
                        : 1000000000, // 设置 scroll-top 为内容高度，使其滚动到底部
                });
            })
            .exec();
    },
    /**
     * 滚动条滚到顶部触发
     */
    scrolltoupper(e: any) {
        const { cursor } = this.data;
        if (cursor != -1) {
            this.setData({
                scrolltoupperFlag: true,
            });
            this.getHistoryList();
        }
    },
    /**
     * 消息设置为已读
     */
    msgRead(info: any) {
        const pages = getCurrentPages();
        console.log("====================================");
        console.warn("已读", pages);
        console.log("====================================");
        if (
            pages.length &&
            pages[pages.length - 1].route !== "pages/profile/userChat/index"
        )
            return;
        let option = {
            chatType: "singleChat", // 会话类型，设置为单聊。
            type: "channel", // 消息类型。channel 表示会话已读回执。
            to: info.userId, // 接收消息对象的用户 ID。
        };
        let msg = wx.WebIM.message.create(option);
        wx.conn.send(msg);
    },
    /**
     * 接收消息监听
     */
    takeOverMsg() {
        const that = this;
        const { targetUserInfo } = this.data;
        wx.conn.addEventHandler("eventName", {
            onReceivedMessage: (message: any) => {
                // 消息到达服务器
                const i = this.data.messageData.findIndex(
                    (v) => v.id === message.id
                );
                if (i !== -1) {
                    this.data.messageData[i].sendStatus = "success";
                    this.data.messageData[i].id = message.mid;
                    this.setData({
                        messageData: [...this.data.messageData],
                    });
                }
            },
            onCmdMessage: (message: any) => {
                console.log(message);
                if (message.action === "focus" && message.ext[message.from]) {
                    this.setData({ isInput: true });
                } else {
                    this.setData({ isInput: false });
                }
                console.log("====================================");
                console.log(this.data.isInput);
                console.log("====================================");
                this.setScrollToBottom();
            },
            onReadMessage: (message: any) => {
                console.log("====================================");
                console.log("已读消息", message);
                console.log("====================================");
            },
            onModifiedMessage: (message: any) => {
                // 修改消息（是否播放过）
                // const i = this.data.messageData.findIndex(
                //     (v) => v.id === message.id
                // );
                // if (i !== -1 && message.from !== this.data.loginInfo.userId) {
                //     this.data.messageData[i].ext = message.ext;
                //     this.setData({
                //         messageData: [...this.data.messageData],
                //     });
                // }
            },
            // 收到文本消息
            onTextMessage: function (message: any) {
                // 判断如果这条消息不是来自当前点击的用户，就不往下执行
                if (message.from !== targetUserInfo.userId) return;
                const { messageData } = that.data;
                messageData.push(message);
                that.handleMessage(messageData);
            },
            // 当前用户收到语音消息。onCustomMessage ,onAudioMessage
            onCustomMessage: function (message: any) {
                // 判断如果这条消息不是来自当前点击的用户，就不往下执行
                if (message.from !== targetUserInfo.userId) return;
                const { messageData } = that.data;
                // 语音文件在服务器的地址。message.url
                messageData.push(message);
                that.handleMessage(messageData);
            },
            // 收到图片消息
            onImageMessage: function (message: any) {
                // 判断如果这条消息不是来自当前点击的用户，就不往下执行
                if (message.from !== targetUserInfo.userId) return;
                const { messageData } = that.data;
                messageData.push(message);
                that.handleMessage(messageData);
            },
            // 收到视频消息
            onVideoMessage: function (message: any) {
                // 判断如果这条消息不是来自当前点击的用户，就不往下执行
                if (message.from !== targetUserInfo.userId) return;
                const { messageData } = that.data;
                messageData.push(message);
                // 视频文件在服务器的地址。
                console.log(message.url);
                // 视频首帧缩略图文件在服务器的地址。
                console.log(message.thumb);
                that.handleMessage(messageData);
            },
        });
    },
    shouldShowTime(lastTimestamp: any, currentTimestamp: any) {
        // 获取当前时间和上一条消息时间的差值（单位：秒）
        const diff = currentTimestamp - lastTimestamp;
        // 假设如果消息间隔小于 1 小时（3600秒），就不显示时间
        // return diff >= 3600000;  // 1小时
        return diff >= 1800000; // 半小时
    },
    /**
     * 处理 IM 返回的的消息数据
     * @param arr
     */
    handleMessage(arr: any) {
        // 当前用户来新消息标记为已读
        this.msgRead({ userId: this.data.targetUserInfo.userId });
        const that = this;
        const currentDate = dayjs().format("YYYY-MM-DD");
        const { targetUserInfo, loginInfo, scrolltoupperFlag, msgFlag } =
            this.data;
        arr.length > 0 &&
            arr.map((item: any, index: any) => {
                const date = dayjs(item.time).format("YYYY-MM-DD HH:mm:ss");
                item.createTime = dayjs(item.time).format("H:mm A");
                item.createDate =
                    dayjs(item.time).format("YYYY-MM-DD") == currentDate
                        ? item.createTime
                        : dayjs(item.time).format("YYYY-MM-DD HH:mm:ss");
                item.sender = item.from == loginInfo.userId ? true : false; // 发送者的userId如果是本地登录用户的id，那么这条消息就是我是发送者
                item.message = item.msg;
                item.timeText = dayjs(item.time).format("mm:ss");
                item.currentRead = false; // 音频当前是否播放的判断标识
                item.avatar =
                    targetUserInfo.avatarurl ||
                    "https://res.wx.qq.com/wxdoc/dist/assets/img/0.4cb08bb4.jpg";
                item.msgTime = formatTimestamp(item.time);
                const showTime =
                    index === 0 ||
                    that.shouldShowTime(arr[index - 1].time, item.time);
                // 以为第一条消息默认都要展示时间
                item.showTime = index === 0 ? true : showTime;
            });
        let list1 = arr;
        // if (msgFlag) {
        //   const history = wx.getStorageSync(targetUserInfo.userId) || [];
        //   list1 = [...history, ...arr]
        // }
        // const list2 = that.saveChatHistory(targetUserInfo.userId, list1)
        // wx.setStorageSync(targetUserInfo.userId, arr);
        wx.setStorageSync(targetUserInfo.userId, list1);
        that.setData(
            {
                messageData: arr,
            },
            () => {
                // 说明往上滑动了，加载了数据
                if (!scrolltoupperFlag) {
                    that.setScrollToBottom();
                }
            }
        );
    },
    /**
     * 视频改变事件
     * @param e
     */
    videoChange(e: any) {
        if (e.detail) {
            // this.sendPrivateVideo(e.detail)
            this.sendPrivateUrlVideo(e.detail);
        }
    },
    /**
     * 上传图片完后触发此回调
     * @param e
     */
    imgChange(e: any) {
        if (e.detail) {
            // this.sendPrivateImg(e.detail)
            this.sendPrivateUrlImg(e.detail);
        }
    },
    /**
     * 输入框改变事件(或者点击了发送触发)
     */
    textareaChange(e: any) {
        this.setData(
            {
                textareaValue: e.detail,
            },
            () => {
                this.sendTextMessage();
            }
        );
    },
    closePopup() {
        this.setData({ showEventPopup: false });
    },
    onClosePopup(e: baseEvent) {
        const leave = e.target.dataset.leave;
        leave && console.log("离开群组");
        const customPopup = this.selectComponent("#event-popup");
        customPopup && customPopup.hidePopup();
    },
    onBack() {
        this.setData({ showEventPopup: true });
    },
    formatDate(data: messageType) {
        const newArr: messageType[] = [];
        let lastdate = "";
        data.forEach((i: messageType) => {
            const { date, createTime, createDate } = formatMessageDate(
                i.timestamp
            );
            newArr.push({
                ...i,
                createTime,
                createDate: lastdate !== createDate ? date : "",
            });
            lastdate = createDate;
        });
    },
    // 监听聊天窗口的滚动事件
    onChatScroll(event) {
        const scrollTop = event.detail.scrollTop;
        const chatWindow = event.target;
        const { loading } = this.data;
        // 判断用户是否滚动到顶部
        if (scrollTop === 0 && !loading) {
            // loading = true; // 避免重复加载
            // loadMoreMessages('chat-id').then(() => {
            //   loading = false;
            // });
        }
    },
    // 假设我们已经从环信SDK获取到了一些历史消息
    // loadHistoryMessages(conversationId: any) {
    //   const messages = wx.getStorageSync(`chat_messages_${conversationId}`) || [];
    //   // 请求更多历史消息（比如通过环信接口获取）
    //   const newMessages = fetchMessagesFromIM(conversationId); // 自定义请求历史消息的函数
    //   const allMessages = newMessages.concat(messages);
    //   // 更新本地缓存
    //   wx.setStorageSync(`chat_messages_${conversationId}`, allMessages);
    //   return allMessages;
    // },
    // 获取新消息后更新缓存
    // onNewMessageReceived(conversationId: any, newMessage: any) {
    //   const messages = wx.getStorageSync(`chat_messages_${conversationId}`) || [];
    //   messages.push(newMessage);
    //   // 保证只保存最新的 N 条消息，删除最旧的
    //   if (messages.length > 100) {
    //     messages.shift();  // 删除最旧的消息
    //   }
    //   // 更新本地缓存
    //   wx.setStorageSync(`chat_messages_${conversationId}`, messages);
    // },
    /**
     * 数组去重
     * @param tempArr
     */
    arrayUnique(tempArr: any) {
        let newArr = [];
        for (let i = 0; i < tempArr.length; i++) {
            const list = newArr.filter((item) => item.id == tempArr[i].id);
            if (list.length == 0) {
                newArr.push(tempArr[i]);
            }
        }
        return newArr;
    },
    /**
     * 保存聊天记录
     * @param conversationId
     * @param messages
     */
    saveChatHistory(conversationId: string, messages: any[]) {
        const history = wx.getStorageSync(conversationId) || [];
        const list1 = [...history, ...messages];
        const arr = this.arrayUnique(list1);
        wx.setStorageSync(conversationId, arr);
        return arr;
    },
    /**
     * 获取历史消息
     */
    getHistoryList() {
        const { targetUserInfo, loginInfo, cursor } = this.data;
        // const messagesHisList = wx.getStorageSync(`chat_messages_${targetUserInfo.userId}`) || [];
        const that = this;
        let options = {
            targetId: targetUserInfo.userId, // 单聊为对端用户 ID，群组聊天为群组 ID。
            chatType: "singleChat", // 会话类型：单聊、群组聊天和聊天室分别为 `singleChat`、`groupChat` 和 `chatRoom`。
            pageSize: 50, // 每次获取的消息数量，取值范围为 [1,50]，默认值为 `50`。最大50条
            cursor: cursor || -1, // 查询的起始消息 ID。若该参数设置为 `-1`、`null` 或空字符串，从最新消息开始。
            searchDirection: "up", // 消息搜索方向。`up` 表示按消息时间戳递减的方向获取，即先获取最新消息；`down` 表示按消息时间戳递增的方向获取，即先获取最老的消息。
            searchOptions: {
                from: loginInfo.userId, // 消息发送方的用户 ID。该参数仅用于群组聊天。
                // msgTypes: ['txt'], // 要获取的消息类型的数组。若不传值，会获取所有类型的消息。
                msgTypes: ["txt", "img", "video", "custom"], // 要获取的消息类型的数组。若不传值，会获取所有类型的消息。
                // startTime: dayjs().subtract(1, 'day').valueOf(), // 查询的起始时间戳，单位为毫秒。
                // endTime: dayjs().valueOf(), // 查询的结束时间戳，单位为毫秒。
            },
        };
        wx.conn.getHistoryMessages(options).then((res: any) => {
            if (res.messages.length > 0) {
                // const newMessages = this.data.messageData.concat(res.messages);
                // const newMessages = [...res.messages, ...this.data.messageData]
                // const newMessages = [...this.data.messageData, ...res.messages, ...messagesHisList]
                // const newMessages = [...res.messages, ...this.data.messageData]
                const list = res.messages.reverse();
                const newMessages = [...list, ...this.data.messageData];
                let msgFlag = that.data.cursor == res.cursor ? true : false;
                that.handleMessage(newMessages);
                // 因为，如果没有数据的话，返回的是字符串类型的undefined，所以得这么判断
                that.setData({
                    cursor:
                        res.cursor && res.cursor != "undefined"
                            ? res.cursor
                            : -1, // 更新游标
                    msgFlag: msgFlag,
                });
            }
        });
    },
    // 暂时没用
    sendPrivateImg(res: any) {
        const that = this;
        const { targetUserInfo } = this.data;
        var tempFilePaths = res.tempFilePaths;
        var token = wx.conn.context.accessToken;
        wx.getImageInfo({
            src: res.tempFilePaths[0],
            success(res1: any) {
                var allowType = {
                    jpg: true,
                    gif: true,
                    png: true,
                    bmp: true,
                };
                var str = wx.conn.appKey.split("#");
                var width = res1.width;
                var height = res1.height;
                var index = res1.path.lastIndexOf(".");
                var filetype = (~index && res1.path.slice(index + 1)) || "";
                var domain = wx.conn.apiUrl + "/";
                if (filetype.toLowerCase() in allowType) {
                    wx.uploadFile({
                        url: domain + str[0] + "/" + str[1] + "/chatfiles",
                        filePath: tempFilePaths[0],
                        name: "file",
                        header: {
                            Authorization: "Bearer " + token,
                        },
                        success(res2: any) {
                            if (res2.statusCode === 400) {
                                // 图片上传阿里云检验不合法
                                var errData = JSON.parse(res2.data);
                                if (errData.error === "content improper") {
                                    wx.showToast({
                                        title: "图片不合法",
                                    });
                                    return false;
                                }
                            }
                            var data = res2.data;
                            var dataObj = JSON.parse(data);
                            var option = {
                                type: "img",
                                chatType: "singleChat",
                                width: width,
                                height: height,
                                url:
                                    dataObj.uri +
                                    "/" +
                                    dataObj.entities[0].uuid,
                                // 消息接收方：单聊为对方用户 ID，群聊和聊天室分别为群组 ID 和聊天室 ID。
                                to: targetUserInfo.userId,
                            };
                            let msg = wx.WebIM.message.create(option);
                            // 调用 `send` 方法发送该图片消息。
                            wx.conn
                                .send(msg)
                                .then((res3: any) => {
                                    // 图片消息成功发送。
                                    that.getHistoryList();
                                })
                                .catch((e) => {
                                    // 图片消息发送失败。
                                    console.log("Fail");
                                });
                        },
                    });
                }
            },
        });
    },
    // 输入中状态
    changeInput(val: any) {
        console.log(val.detail, "输入");
        const { targetUserInfo, loginInfo } = this.data;
        let option = {
            type: "cmd",
            to: targetUserInfo.userId,
            chatType: "singleChat",
            action: val.detail ? "focus" : "blur",
            ext: {} as any,
        };
        option.ext[loginInfo.userId] = val.detail ? true : false;
        let msg = wx.WebIM.message.create(option);
        // 调用 `send` 方法发送该文本消息。
        wx.conn
            .send(msg)
            .then((res: any) => {
                console.log(res);
            })
            .catch((e: any) => {
                console.log(e, "错误");
            });
    },
    // 发送语音消息
    audioChange(e: any) {
        const info = e.detail;
        const { targetUserInfo, loginInfo } = this.data;
        // 处理临时的发送中的消息
        // this.loadingMsg(info, "audio");
        let option = {
            // 消息类型。
            type: "custom",
            // 消息接收方：单聊为对方用户 ID，群聊和聊天室分别为群组 ID 和聊天室 ID。
            to: targetUserInfo.userId,
            // 会话类型：单聊、群聊和聊天室分别为 `singleChat`、`groupChat` 和 `chatRoom`。
            chatType: "singleChat",
            customEvent: "customEvent",
            // key 和 value 只支持字符串类型，否则客户端无法解析。
            customExts: {
                //文件 URL。
                url: info.url,
                //文件类型。
                type: "audio",
                //文件名。
                filename: "filename",
                // 音频文件时长，单位为秒。
                length:
                    Math.ceil(info.duration / 1000) > 60
                        ? 60
                        : Math.ceil(info.duration / 1000).toString(),
            },
            // 消息扩展字段，不能设置为空，即设置为 "ext:null" 会出错。
            ext: { isPlay: false, isPlayMe: false } as any,
        };
        option.ext[targetUserInfo.userId] = false;
        let msg = wx.WebIM.message.create(option);
        msg.sendStatus = "loading";
        msg.from = this.data.loginInfo.userId;
        msg.createTime = dayjs().format("H:mm A");
        msg.createDate = dayjs().format("YYYY-MM-DD HH:mm:ss");
        msg.sender = true;
        this.setData({ messageData: [...this.data.messageData, msg] }, () => {
            // 滚动到底部
            this.setScrollToBottom();
        });
        // 调用 `send` 方法发送该文本消息。
        wx.conn
            .send(msg)
            .then((res: any) => {
                // 发送成功后清楚消息输入框内容
                this.setData({
                    textareaValue: "",
                });
                // 调用获取历史消息
                // this.getHistoryList();
                this.chatMark();
            })
            .catch((e: any) => {
                console.log(e, "错误");
                this.sendFailed(option, "audio", e.type);
            });
    },
    // 播放语音
    sendCMDMessage(obj: any) {
        console.log(obj);
        const { targetUserInfo, loginInfo } = this.data;
        if (
            obj.detail.from === loginInfo.userId ||
            obj.detail.ext[loginInfo.userId]
        ) {
            return;
        }
        let params = {
            msgId: obj.detail.id,
            newMsgType: obj.detail.type,
            newTxtMsg: "",
            newCustomExts: obj.detail.customExts,
            newExt: { ...obj.detail.ext } as any,
        };
        params.newExt[loginInfo.userId] = true;
        rewriteImMessage(params).then((res: any) => {
            const i = this.data.messageData.findIndex(
                (v) => v.id === obj.detail.id
            );
            if (i !== -1) {
                this.data.messageData[i].ext[loginInfo.userId] = true;
                this.setData({
                    messageData: [...this.data.messageData],
                });
            }
        });
    },
    /**
     * 处理发送消息
     * 更新当前消息列表，两个触发位置（消息监听、发送方调用发送）
     * @param data
     */
    updateMessageList(data: any) {
        let message = {};
        if (data?.detail) {
            message = {
                ...data.detail,
            };
        } else {
            message = {
                ...data,
            };
        }
        const arr1 = [message];
        const arr = [...this.data.messageData, ...arr1];
        let list: any = [];
        arr.map((item: any) => {
            if (item.sendStatus && item.sendStatus == "loading") {
                // 有的加载中
                // 过滤出是否有重复的，然后再根据判断，如果有重复的就处理重复的，如果没有就直接push到list里面去
                let list3: any = [];
                if (item.type == "txt") {
                    // 文本消息
                    // 查找下标
                    const selectIndex = list.findIndex(
                        (everyOne: any) =>
                            everyOne.createDate == item.createDate &&
                            everyOne.msg == item.msg
                    );
                    if (selectIndex != -1) {
                        // 说明有重复的，就push不等于loading的
                        // if (item.sendStatus != "loading") {
                        //   list.push(item)
                        // }
                        list.push(item);
                    } else {
                        // 说明没有重复的，直接push
                        list[selectIndex] = item;
                    }
                } else {
                    // 视频、图片、音频
                    const selectIndex = list.findIndex(
                        (everyOne: any) =>
                            everyOne.createDate == item.createDate &&
                            everyOne.msg == item.msg
                    );
                    if (selectIndex != -1) {
                        // 说明有重复的，就push不等于loading的
                        list.push(item);
                    } else {
                        // 说明没有重复的，直接push
                        list[selectIndex] = item;
                    }
                }
            } else {
                // 说明没有加载中的，直接push
                list.push(item);
            }
        });
        // this.handleMessage(arr)
        this.handleMessage(list);
        // this.setData({
        //   messageData: [...this.data.messageData, message],
        // });
        //处理作为消息发送方更新会话列表（接收方会话列表的更新已经在app.js中的消息监听做了处理。）
        // if (message.from === EMClient.user) {
        //   this.updateConversationLastMessage({ ...message });
        // }
        // this.processGroupMessageList();
        // this.callScrollToBottom();
    },
    /**
     * 处理正在发送中的消息
     */
    loadingMsg(info: any, type: any) {
        const { targetUserInfo, loginInfo, tempMessageId } = this.data;
        // 生成一个新的临时消息ID
        const newTempMessageId = tempMessageId + 1;
        // 创建一个临时消息项
        if (type == "txt") {
            // 文本消息
            const tempMessage = {
                id: newTempMessageId,
                type: type || "txt",
                sendStatus: "loading", // 设置消息类型为loading
                msg: info,
                from: loginInfo.userId,
                sender: true, // 发送者的userId如果是本地登录用户的id，那么这条消息就是我是发送者
                avatar:
                    loginInfo.avatar ||
                    "https://res.wx.qq.com/wxdoc/dist/assets/img/0.4cb08bb4.jpg",
                createTime: dayjs().format("HH:mm:ss"),
                createDate: dayjs().format("YYYY-MM-DD HH:mm:ss"),
                showTime: true, // 假设第一条消息默认都要展示时间
            };
            // 更新消息列表，添加临时消息项
            this.setData(
                {
                    messageData: [...this.data.messageData, tempMessage],
                    tempMessageId: newTempMessageId,
                },
                () => {
                    // 滚动到底部
                    this.setScrollToBottom();
                }
            );
        } else {
            let tempMessage: any = {
                id: newTempMessageId,
                type: type || "img",
                sendStatus: "loading", // 设置消息类型为loading
                url: info.url,
                from: loginInfo.userId,
                sender: true, // 发送者的userId如果是本地登录用户的id，那么这条消息就是我是发送者
                avatar:
                    loginInfo.avatar ||
                    "https://res.wx.qq.com/wxdoc/dist/assets/img/0.4cb08bb4.jpg",
                createTime: dayjs().format("HH:mm:ss"),
                createDate: dayjs().format("YYYY-MM-DD HH:mm:ss"),
                showTime: true, // 假设第一条消息默认都要展示时间
            };
            if (info.type === "audio") {
                tempMessage.customExts = {
                    url: info.url,
                    type: "audio",
                    filename: "filename",
                    length: Math.ceil(info.duration / 1000).toString(),
                };
            }
            // 更新消息列表，添加临时消息项
            this.setData(
                {
                    messageData: [...this.data.messageData, tempMessage],
                    tempMessageId: newTempMessageId,
                },
                () => {
                    // 滚动到底部
                    this.setScrollToBottom();
                }
            );
            // let option = {
            //   chatType: "singleChat",
            //   // 消息类型。
            //   type: info.fileType || "video",
            //   url: info.url,
            //   filename: 'filename',
            //   body: {
            //     url: info.url,
            //     video: info.fileType || "video",
            //     filename: 'filename',
            //   },
            //   // 消息接收方：单聊为对方用户 ID，群聊和聊天室分别为群组 ID 和聊天室 ID。
            //   to: targetUserInfo.userId,
            // };
        }
    },
    // 发送失败
    sendFailed(option: any, type: string, status: any, msgInfo?: any) {
        const { loginInfo } = this.data;
        console.log(msgInfo, status);
        if (status != 603 && status != 221 && status != 207) {
            const i = this.data.messageData.findIndex(
                (v) => v.id === msgInfo.id
            );
            if (i !== -1) {
                this.data.messageData[i].sendStatus = "fail";
                this.data.messageData[i].ext = {
                    type: "fail",
                };
                this.setData({
                    messageData: [...this.data.messageData],
                });
            }
            return;
        }
        option.to = loginInfo.userId;
        option.ext = {
            ...option.ext,
            type: "fail",
            isBlack: status == 603,
            isDelFriend: status == 221,
            isLogout: status == 207,
        };
        let msg = wx.WebIM.message.create(option);
        // 调用 `send` 方法发送该文本消息。
        wx.conn
            .send(msg)
            .then((res) => {
                this.updateMessageList(res.message);
                this.chatMark();
            })
            .catch((e) => {
                console.log("fail", e);
            });
    },
    /**
     * 发送文本消息
     */
    sendTextMessage() {
        const { textareaValue, targetUserInfo, loginInfo } = this.data;
        // 处理临时的发送中的消息
        // this.loadingMsg(textareaValue, "txt");
        const that = this;
        let option = {
            // 消息类型。
            type: "txt",
            // 消息内容。
            msg: textareaValue,
            from: loginInfo.userId,
            // 消息接收方：单聊为对方用户 ID，群聊和聊天室分别为群组 ID 和聊天室 ID。
            to: targetUserInfo.userId,
            // 会话类型：单聊、群聊和聊天室分别为 `singleChat`、`groupChat` 和 `chatRoom`，默认为单聊。
            chatType: "singleChat",
        };
        let msg = wx.WebIM.message.create(option);
        msg.sendStatus = "loading";
        msg.from = this.data.loginInfo.userId;
        msg.createTime = dayjs().format("H:mm A");
        msg.createDate = dayjs().format("YYYY-MM-DD HH:mm:ss");
        msg.sender = true;
        this.setData({ messageData: [...this.data.messageData, msg] }, () => {
            // 滚动到底部
            this.setScrollToBottom();
        });
        // 调用 `send` 方法发送该文本消息。
        wx.conn
            .send(msg)
            .then((res) => {
                // 发送成功后清除消息输入框内容
                that.setData({
                    textareaValue: "",
                });
                // 这里以下修改=============
                // this.sendMsgHandle('txt', res)
                // 这里以上修改=============
                // that.updateMessageList(res.message);
                that.chatMark();
            })
            .catch((e) => {
                console.log("====================================");
                console.log("发送失败", e);
                console.log("====================================");
                // 清除消息输入框内容
                this.setData({
                    textareaValue: "",
                });
                this.sendFailed(option, "txt", e.type, msg);
            });
    },
    formatTimeVideo(seconds: number) {
        const minutes = Math.floor(seconds / 60);
        const secs = Math.floor(seconds % 60);

        return `${String(minutes).padStart(2, "0")}:${String(secs).padStart(
            2,
            "0"
        )}`;
    },
    // 获取视频时长
    getLength(e: any) {
        const duration = Number(
            e.detail.detail.duration
                ? e.detail.detail.duration
                : e.detail.duration
        );
        //处理时间格式并存放到data中
        wx.nextTick(() => {
            const i = this.data.messageData.findIndex(
                (v) => v.id === e.detail.target.dataset.msgid
            );
            if (i !== -1) {
                if (this.data.messageData[i].ext != undefined) {
                    this.data.messageData[i].ext[
                        "duration"
                    ] = `${this.formatTimeVideo(duration)}`;
                } else {
                    this.data.messageData[i].ext = {
                        duration: `${this.formatTimeVideo(duration)}`,
                    };
                }
                this.setData({
                    messageData: [...this.data.messageData],
                });
            }
        });
    },
    /**
     * 发送视频消息（视频已上传到我们服务器）
     */
    sendPrivateUrlVideo(info: any) {
        const { targetUserInfo } = this.data;
        const that = this;
        // 处理临时的发送中的消息
        // this.loadingMsg(info, "video");
        let option = {
            chatType: "singleChat",
            // 消息类型。
            type: info.fileType || "video",
            url: info.url,
            filename: "filename",
            body: {
                url: info.url,
                video: info.fileType || "video",
                filename: "filename",
            },
            // 消息接收方：单聊为对方用户 ID，群聊和聊天室分别为群组 ID 和聊天室 ID。
            to: targetUserInfo.userId,
        };
        // 创建一条图片消息。
        let msg = wx.WebIM.message.create(option);
        msg.sendStatus = "loading";
        msg.from = this.data.loginInfo.userId;
        msg.sender = true;
        msg.url = info.url;
        this.setData({ messageData: [...this.data.messageData, msg] }, () => {
            // 滚动到底部
            this.setScrollToBottom();
        });
        // 调用 `send` 方法发送该文本消息。
        wx.conn
            .send(msg)
            .then((res: any) => {
                setTimeout(() => {
                    // that.getHistoryList()
                    // that.updateMessageList(res.message);
                    that.chatMark();
                }, 100);
            })
            .catch((e: any) => {
                // 清除消息输入框内容
                let msg = e.message == "blocked" ? "黑名单" : e.message;
                // type == 603  拉黑
                // this.setData({
                //     blackNameFlag: e.message == "blocked" ? true : false,
                // });
                this.sendFailed(option, "video", e.type);
            });
    },
    /**
     * 发送图片消息（图片已上传到我们服务器）
     */
    sendPrivateUrlImg(info: any) {
        const { targetUserInfo, loginInfo } = this.data;
        const that = this;
        // 处理临时的发送中的消息
        // this.loadingMsg(info, "img");
        let option = {
            chatType: "singleChat",
            // 消息类型。
            type: info.fileType || "img",
            url: info.url,
            body: {
                url: info.url,
            },
            // 消息接收方：单聊为对方用户 ID，群聊和聊天室分别为群组 ID 和聊天室 ID。
            to: targetUserInfo.userId,
        };
        // 创建一条图片消息。
        let msg = wx.WebIM.message.create(option);
        msg.sendStatus = "loading";
        msg.from = this.data.loginInfo.userId;
        msg.sender = true;
        this.setData({ messageData: [...this.data.messageData, msg] }, () => {
            // 滚动到底部
            this.setScrollToBottom();
        });
        wx.conn
            .send(msg)
            .then((res: any) => {
                // setTimeout(() => {
                //     // that.getHistoryList()
                //     that.updateMessageList(res.message);
                //     that.chatMark();
                // }, 100);
            })
            .catch((e: any) => {
                // 清除消息输入框内容
                let msg = e.message == "blocked" ? "黑名单" : e.message;
                // type == 603  拉黑
                // this.setData({
                //     blackNameFlag: e.message == "blocked" ? true : false,
                // });

                this.sendFailed(option, "img", e.type);
            });
    },

    /**
     * 生命周期函数--监听页面显示
     */
    goBack() {
        wx.navigateBack();
    },
    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {},

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {},

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {},

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {},

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {},
});
